package com.project.fortuneteller.service.impl;

import cn.hutool.core.util.ObjectUtil;
import com.project.fortuneteller.mappers.FriendMapper;
import com.project.fortuneteller.mappers.MessageMapper;
import com.project.fortuneteller.mappers.UserMapper;
import com.project.fortuneteller.pojo.Friend;
import com.project.fortuneteller.pojo.User;
import com.project.fortuneteller.pojo.dto.AddNewFriendInfoDto;
import com.project.fortuneteller.pojo.dto.HandleNewFriendDto;
import com.project.fortuneteller.pojo.dto.WebSocketFriendDto;
import com.project.fortuneteller.pojo.vo.AddNewFriendDto;
import com.project.fortuneteller.service.FriendService;
import com.project.fortuneteller.utils.Result;
import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Objects;

@Service
//@RequiredArgsConstructor
public class FriendServiceImpl implements FriendService {
    private static final Logger log = LoggerFactory.getLogger(FriendServiceImpl.class);
    @Resource
    private MessageMapper messageMapper;
    @Resource
    private FriendMapper friendMapper;
    @Resource
    private UserMapper userMapper;
    //注入RedissonClient
    @Autowired
    RedissonClient redissonClient;

    /**
     * 通过 用户 ID 获取 用户好友信息
     * @param userId
     * @return
     */
    public Result findFriends(int userId) {
        // 获取用户ID
        List<Integer> friends = friendMapper.getFriendIdListByUserId(userId);
        List<WebSocketFriendDto> list = new ArrayList<>();

        friends.forEach(f->{
             User user= userMapper.getById(f);
             if(ObjectUtil.isNotNull(user)){
                // 获取 未读消息 数量
                int count = messageMapper.getNoReadCount(userId,f);
                // 使用 建造者模式
                list.add(WebSocketFriendDto.builder()
                        .FriendId(user.getId())
                        .avatar(user.getAvatar())
                        .noReadCount(count)
                        .FriendName(user.getUserName()).build());
            }


        });
        //
        if(friends.isEmpty()){
            return Result.success("你还没有朋友,请在搜索框中添加");
        }

        return Result.success(list);
    }


    /**
     * 添加好友 处理
     * @param handleNewFriendDto
     * @return
     */

    public Result handleAddFriend(Integer userId, HandleNewFriendDto handleNewFriendDto) {
        /**
         * 创建好友之前 需要申请 好友 ,等到 同意之后才创建并添加好友
         */
        // 用户昵称
//        String friendName = userMapper.getUserNameById(handleNewFriendDto.getFriendId());
//        // 好友昵称
//        String userName = userMapper.getUserNameById(userId);

        //获得一个RBucket实现类，参数是redis数据库中的key值
        RBucket<List<AddNewFriendInfoDto>> bucket = redissonClient.getBucket("friendAdd:"+ userId);
        // 获取 好友对象
        List<AddNewFriendInfoDto> friendList = bucket.get();
        Friend friend = new Friend();
        // 表示要删除的好友
        AddNewFriendInfoDto deleteFriend = null;
        for (AddNewFriendInfoDto item : friendList) {
            // 匹配 好友的添加信息
            if(Objects.equals(item.getFriendId(), userId)){
                deleteFriend = item;
                  BeanUtils.copyProperties(item,friend);
            }
        }
        // 只删除一次
        friendList.remove(deleteFriend);
        // 更新缓存
        bucket.set(friendList);
        // 不接受 该用户
        if(handleNewFriendDto.getState()==0){
            return Result.success("不接受该用户,好友已处理");
        }
        int res = 0;
        // 好友信息插入数据库 并删除缓存
        if(friend != null){
            Integer userId1 = friend.getUserId();
            Integer friendId = friend.getFriendId();
            Friend friendTemp = Friend.builder().state(1).userId(friendId).friendId(userId1).build();
            res += friendMapper.insertFriend(friendTemp);
            res += friendMapper.insertFriend(friend);
        }
//        bucket.set(friendList);
        if(res <=1){
            return Result.error("好友添加失败");
        }

        return Result.success("好友已添加");
    }
    /**
     *
     *   申请添加用户为好友
     *      *      * @TODO 申请添加好友
     * @param userId
     * @param friendId
     * @return
     */
    public Result addNewFriend(Integer userId, Integer friendId) {
        // 用户昵称
//        String friendName = userMapper.getUserNameById(friendId);
        // 好友昵称
        String userName = userMapper.getUserNameById(userId);

        if( friendMapper.judgeUserFriendExist(userId, friendId) >0){
            return Result.success("该用户已经是你的好友了,请勿重复添加");
        }

        // 创建 好友对象
        AddNewFriendInfoDto friend = AddNewFriendInfoDto.builder().friendId(friendId).userName(userName)
                // 将 状态设置成 0 表示 为 待对方同意 现在 暂时为 加好友的状态
                .userId(userId).state(1).createTime(new Date()).build();
        // 好友信息插入数据库
        List<AddNewFriendInfoDto> friendList = new ArrayList<>(1);

        //获得一个RBucket实现类，参数是redis数据库中的key值
        // key 为 要添加的好友
        RBucket<List<AddNewFriendInfoDto>> bucket = redissonClient.getBucket("friendAdd:" + friendId);
        friendList = bucket.get();

        if (friendList == null) {
            friendList = new ArrayList<>();
            // 创建空列表
            bucket.set(friendList);
            // 写入 Redis
        }

        if(friendList != null && !friendList.isEmpty()){
            // 获取好友信息列表
            // 避免重复添加
            for(AddNewFriendInfoDto item : friendList){
                if(item.getUserId().equals(userId)){
                    return Result.success("用户已经发送了申请，等待对方同意");
                }
            }
            log.info( "朋友数量: {}", friendList.size() );
            // 添加好友信息
            friendList.add(friend);
            // 更新缓存
            bucket.set(friendList);
            return Result.success("好友申请添加成功");
        }
        //  好友列表 添加该好友
        friendList.add(friend);
        // 缓存好友信息
        bucket.set(friendList);

        return Result.success("好友申请添加成功");
    }


    /**
     * 从缓存中获取待添加的 用户信息
     * @param userId
     * @return
     */
    @Override
    public Result getNewFriendInfo(Integer userId){
        // 获取
        RBucket<List<AddNewFriendInfoDto>> bucket = redissonClient.getBucket("friendAdd:" + userId);
        // 获取用户信息
        List<AddNewFriendInfoDto> friendList = bucket.get();
        //
        return Result.success(friendList);
    }


}
